package com.sgcc.pda.bluetooth.bluetoothmanager;

import android.app.Application;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothManager;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.SystemClock;
import android.text.TextUtils;
import android.util.Log;
import android.widget.Toast;

import com.clj.fastble.BleManager;
import com.clj.fastble.callback.BleGattCallback;
import com.clj.fastble.callback.BleIndicateCallback;
import com.clj.fastble.callback.BleMtuChangedCallback;
import com.clj.fastble.callback.BleNotifyCallback;
import com.clj.fastble.callback.BleReadCallback;
import com.clj.fastble.callback.BleScanCallback;
import com.clj.fastble.callback.BleWriteCallback;
import com.clj.fastble.data.BleDevice;
import com.clj.fastble.exception.BleException;
import com.clj.fastble.scan.BleScanRuleConfig;
import com.sgcc.pda.bluetooth.api.IReceiveCallBack;
import com.sgcc.pda.bluetooth.api.ISendIReceiveCallBack;
import com.sgcc.pda.bluetooth.blueinterface.IBleConnectListener;
import com.sgcc.pda.bluetooth.blueinterface.IOnFoundDeviceListener;
import com.sgcc.pda.bluetooth.blueinterface.IOnReConnectListener;
import com.sgcc.pda.bluetooth.config.Constant;
import com.sgcc.pda.bluetooth.entity.ReturnBean;
import com.sgcc.pda.bluetooth.utils.BlueDeviceInfoUtil;
import com.sgcc.pda.bluetooth.utils.ClsUtils;
import com.sgcc.pda.bluetooth.utils.ToolGson;

import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

import static com.sgcc.pda.bluetooth.config.Constant.BLUE_BLE;
import static com.sgcc.pda.bluetooth.config.Constant.CLS_CONN_OUT_TIME;
import static com.sgcc.pda.bluetooth.config.Constant.CONNECTED;
import static com.sgcc.pda.bluetooth.config.Constant.DISCONNECTED;
import static com.sgcc.pda.bluetooth.config.Constant.FLAG_RECONN;
import static com.sgcc.pda.bluetooth.config.Constant.MESSAGE_BLE_KEY;
import static com.sgcc.pda.bluetooth.config.Constant.RESULT_FAIL;
import static com.sgcc.pda.bluetooth.config.Constant.RESULT_SUCC;
import static com.sgcc.pda.bluetooth.config.Constant.TYPE_RECEIVE;
import static com.sgcc.pda.bluetooth.config.Constant.TYPE_SEND;
import static com.sgcc.pda.bluetooth.config.Constant.UUID_LE_CHARACTERISTIC;
import static com.sgcc.pda.bluetooth.config.Constant.UUID_LE_SERVICE;
import static com.sgcc.pda.bluetooth.utils.ClsUtils.hexString2Bytes;

/**
 * 描 述：ble蓝牙管理类 常用的操作是notify和wirte，
 * 前者是APP接收BLE发过来的数据，后者是APP向BLE设备发送数据。
 *
 * 作 者：yangzhi
 * 时 间：2020/3/5 11:12
 * 版 本：1.0
 * 版 权： Copyright (c) remarkables-united.Co.Ltd. All rights reserved.
 */
public class BleBluetoothManager {

    private static final String TAG = "BlueManager";
    private static BleBluetoothManager mInstance;
    private BluetoothAdapter mBluetoothAdapter;
    private Context context;
    //搜索设备回调
    private IOnFoundDeviceListener mOnFoundDeviceListener;
    //广播接收
//    private BtBroadcastReceiver btBroadcastReceiver;
    //是否自动重连
    private boolean isAutoConnect = false;
    //是否手动断开 手动断开不要再自动连接
    private boolean mIsActiveDisConnected;
    //超时时间
    private long outTime = CLS_CONN_OUT_TIME;
    //自动重连次数  默认10次
    private int mReConnCount = Constant.RE_CONN_COUNT;

    public static BleBluetoothManager getInstance(Context context) {
        synchronized (BleBluetoothManager.class) {
            if (null == mInstance) {
                mInstance = new BleBluetoothManager(context);
            }
        }
        return mInstance;
    }

    private BleBluetoothManager(Context context) {
        this.context = context;
    }


    /**
     * ble蓝牙配置
     *
     * @param isAutoConnect 是否需要自动连接 为true时候如果设备断开了,会不断的尝试自动连接
     */
    public void configBlue(Application application, boolean isAutoConnect, int reConnCount) {
        this.isAutoConnect = isAutoConnect;
        this.mReConnCount = reConnCount;
        final BluetoothManager bluetoothManager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
        mBluetoothAdapter = bluetoothManager.getAdapter();

        if (null == mBluetoothAdapter) {
            Toast.makeText(context, "设备不支持蓝牙", Toast.LENGTH_SHORT).show();
            return;
        }
        BleManager.getInstance().init(application);
        if (!BleManager.getInstance().isSupportBle()) {
            //不支持ble
            Toast.makeText(context, "设备不支持BLE蓝牙", Toast.LENGTH_SHORT).show();
            return;
        }
        //打开蓝牙
        mBluetoothAdapter.enable();
        //
        BleManager.getInstance()
                .enableLog(true)//是否显示蓝牙框架内部log
                .setReConnectCount(mReConnCount, Constant.CLS_AUTO_CONN_TIME)//重连次数、时间间隔
                .setConnectOverTime(outTime)//连接超时时间
                .setOperateTimeout(Constant.OVERTIME);//操作超时时间
        //设置扫描的规则
        BleScanRuleConfig scanRuleConfig = new BleScanRuleConfig.Builder()
//                .setServiceUuids(serviceUuids)      // 只扫描指定的服务的设备，可选
//                .setDeviceName(true, names)         // 只扫描指定广播名的设备，可选
//                .setDeviceMac(mac)                  // 只扫描指定mac的设备，可选
                .setAutoConnect(isAutoConnect)      // 连接时的autoConnect参数，可选，默认false
                .setScanTimeOut(Constant.SCAN_OVER_TIME)              // 扫描超时时间，可选，默认10秒 小于等于0表示不限制扫描时间
                .build();
        BleManager.getInstance().initScanRule(scanRuleConfig);
    }


    public void setOutTime(long outTime) {
        this.outTime = outTime;
    }

    /**
     * 判断蓝牙是否可用
     */
    public boolean isBlueEnable() {
        return BleManager.getInstance().isSupportBle() && BleManager.getInstance().isBlueEnable();
    }


    /**
     * 设置自动重连的监听
     */
    private IOnReConnectListener onReConnectListener;

    public void setAutoConnListener(IOnReConnectListener onReConnectListener) {
        this.onReConnectListener = onReConnectListener;
    }

    /**
     * 扫描蓝牙设备
     *
     * @param onFoundDeviceListener 扫描设备监听
     */

    public void scanDevice(final IOnFoundDeviceListener onFoundDeviceListener) {
        this.mOnFoundDeviceListener = onFoundDeviceListener;
        if (!mBluetoothAdapter.isEnabled()) {
            Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            context.startActivity(enableBtIntent);
            return;
        }


        if (mBluetoothAdapter.isDiscovering()) { //当前正在搜索设备...
            return;
        }
        BleManager.getInstance().scan(new BleScanCallback() {
            @Override
            public void onScanStarted(boolean success) {
                //会回到主线程，参数表示本次扫描动作是否开启成功。由于蓝牙没有打开，上一次扫描没有结束等原因，会造成扫描开启失败
                if (success) {
                    onFoundDeviceListener.bluetoothScanStart();
                }
            }

            @Override
            public void onLeScan(BleDevice bleDevice) {
                super.onLeScan(bleDevice);
                //扫描过程中所有被扫描到的结果回调。由于扫描及过滤的过程是在工作线程中的，此方法也处于工作线程中。同一个设备会在不同的时间，
                // 携带自身不同的状态（比如信号强度等），出现在这个回调方法中，出现次数取决于周围的设备量及外围设备的广播间隔。
            }

            @Override
            public void onScanning(BleDevice bleDevice) {
                //扫描过程中的所有过滤后的结果回调。与onLeScan区别之处在于：
                // 它会回到主线程；同一个设备只会出现一次；出现的设备是经过扫描过滤规则过滤后的设备。
                onFoundDeviceListener.bleFoundDevice(bleDevice);
            }

            @Override
            public void onScanFinished(List<BleDevice> scanResultList) {
                //本次扫描时段内所有被扫描且过滤后的设备集合。它会回到主线程，相当于onScanning设备之和。
                onFoundDeviceListener.bluetoothScanFinsh();
            }
        });
    }

    /**
     * 取消扫描
     */

    public void cancelScan() {
        BleManager.getInstance().cancelScan();
    }


    /**
     * 连接设备
     *
     * @param bleDevice          蓝牙设备
     * @param bleConnectListener 连接状态监听
     */
    public void startConn(final BleDevice bleDevice, final IBleConnectListener bleConnectListener) {
        BleManager.getInstance().connect(bleDevice, new BleGattCallback() {
            @Override
            public void onStartConnect() {
                if (mBluetoothAdapter.isDiscovering()) {
                    mBluetoothAdapter.cancelDiscovery();
                }
                bleConnectListener.onStartConn();
            }

            @Override
            public void onConnectFail(BleDevice bleDevice, BleException exception) {
                bleConnectListener.onConnFailure(exception.toString());
            }

            @Override
            public void onConnectSuccess(BleDevice bleDevice, BluetoothGatt gatt, int status) {
                BlueDeviceInfoUtil.getInstance().setDeviceInfo(BLUE_BLE, ToolGson.getJsonStr(bleDevice), CONNECTED);
                bleConnectListener.onConnSuccess();
            }

            @Override
            public void onDisConnected(boolean isActiveDisConnected, BleDevice device, BluetoothGatt gatt, int status) {
                //连接断开，特指连接后再断开的情况。在这里可以监控设备的连接状态，
                // 此外，如果通过调用disconnect(BleDevice bleDevice)方法，主动断开蓝牙连接的结果
                // 也会在这个方法中回调，此时isActiveDisConnected将会是true。
                Log.e(TAG, bleDevice.getName() + "连接断开");
                BlueDeviceInfoUtil.getInstance().setDeviceInfo(BLUE_BLE, ToolGson.getJsonStr(bleDevice), DISCONNECTED);
                mIsActiveDisConnected = isActiveDisConnected;
                if (isActiveDisConnected) {
                    Log.e(TAG, bleDevice.getName() + "主动断开");
                }
                if (isAutoConnect) {
                    autoConnTask(device);
                }
            }
        });

    }

    /**
     * 自动连接
     *
     * @param bleDevice 蓝牙设备
     */
    private void autoConn(final BleDevice bleDevice) {
        BleManager.getInstance().connect(bleDevice, new BleGattCallback() {
            @Override
            public void onStartConnect() {
                if (null != onReConnectListener) {
                    onReConnectListener.onStartConn();
                }
                Log.e(TAG, bleDevice.getName() + "自动重连，开始连接");
            }

            @Override
            public void onConnectFail(BleDevice bleDevice, BleException exception) {
                Log.e(TAG, bleDevice.getName() + "自动重连，连接失败");
                if (null != onReConnectListener) {
                    onReConnectListener.onConnFailure();
                }
                BlueDeviceInfoUtil.getInstance().setDeviceInfo(BLUE_BLE, ToolGson.getJsonStr(bleDevice), DISCONNECTED);
            }

            @Override
            public void onConnectSuccess(BleDevice bleDevice, BluetoothGatt gatt, int status) {
                Log.e(TAG, bleDevice.getName() + "自动重连，连接成功");
                BlueDeviceInfoUtil.getInstance().setDeviceInfo(BLUE_BLE, ToolGson.getJsonStr(bleDevice), CONNECTED);
                if (null != timer) {
                    timer.cancel();
                    timer = null;
                }
                if (null != onReConnectListener) {
                    onReConnectListener.onConnSuccess();
                }
            }

            @Override
            public void onDisConnected(boolean isActiveDisConnected, BleDevice device, BluetoothGatt gatt, int status) {
                BlueDeviceInfoUtil.getInstance().setDeviceInfo(BLUE_BLE, ToolGson.getJsonStr(bleDevice), DISCONNECTED);
            }
        });

    }


    private Timer timer;

    /**
     * 自动重连
     * 每隔10s执行一次重连方法
     *
     * @param device 蓝牙设备
     */
    private void autoConnTask(final BleDevice device) {
        timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                Message message = new Message();
                message.what = FLAG_RECONN;
                Bundle bundle = new Bundle();
                if (null != device) {
                    bundle.putParcelable(MESSAGE_BLE_KEY, device);
                }
                message.setData(bundle);
                mHandler.sendMessage(message);
            }
        }, 1000, 10000);

    }

    private Handler mHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case FLAG_RECONN:
                    Log.e(TAG, "自动重连");
                    //不是手动断开的情况设置重连
                    if (!mIsActiveDisConnected) {
                        BleDevice bleDevice = msg.getData().getParcelable(MESSAGE_BLE_KEY);
                        if (null != bleDevice) {
                            autoConn(bleDevice);
                        }
                    }
                    break;
                default:
                    break;
            }
        }
    };


    /**
     * 判断蓝牙连接状态
     *
     * @param bleDevice 蓝牙对象
     * @return true 已连接
     */
    public boolean isConn(BleDevice bleDevice) {
        return BleManager.getInstance().isConnected(bleDevice);
    }

    /**
     * 判断蓝牙连接状态
     *
     * @param mac 蓝牙地址
     * @return true 已连接
     */
    public boolean isConn(String mac) {
        return BleManager.getInstance().isConnected(mac);
    }


    /**
     * 发送接收数据
     */

    public void sendData(final BleDevice bleDevice, String data, final ISendIReceiveCallBack callBack) {
        if (null == bleDevice) {
            Log.e(TAG, "bleDevice == null");
            return;
        }
        if (TextUtils.isEmpty(data)) {
            Log.e(TAG, "sendData:string-->要发送的数据为空");
            return;
        }
        data.replace(" ", "");  //取消空格
        //检查16进制数据是否合法
        if (data.length() % 2 != 0) {
            Log.e(TAG, "sendData:string-->数据不合法");
            return;
        }
        Log.e(TAG, "sendData:string -->准备写入：" + data);
        /**
         * 发送数据
         */
        writeData(bleDevice, hexString2Bytes(data), new BleWriteCallback() {
            @Override
            public void onWriteSuccess(int current, int total, byte[] justWrite) {
                //`current`表示当前发送第几包数据，`total`表示本次总共多少包数据,`justWrite`表示刚刚发送成功的数据包
                Log.e(TAG, "current:" + current + "   total" + total);
                if (current == total) {
                    ReturnBean returnBean = new ReturnBean();
                    returnBean.setType(TYPE_SEND);
                    returnBean.setCode(RESULT_SUCC);
                    if (null != callBack) {
                        callBack.sendResult(returnBean);
                    }
                    //发送完成
                    SystemClock.sleep(200);
                    notifyData(bleDevice, new BleNotifyCallback() {
                        @Override
                        public void onNotifySuccess() {

                        }

                        @Override
                        public void onNotifyFailure(BleException exception) {
                            //接收失败
                            ReturnBean returnBean = new ReturnBean();
                            returnBean.setType(TYPE_RECEIVE);
                            returnBean.setCode(RESULT_FAIL);
                            returnBean.setData(exception.toString());
                            if (null != callBack) {
                                callBack.receiveResult(returnBean);
                            }
                        }

                        @Override
                        public void onCharacteristicChanged(byte[] data) {
                            ReturnBean returnBean = new ReturnBean();
                            returnBean.setType(TYPE_RECEIVE);
                            returnBean.setCode(RESULT_SUCC);
                            if (null != data && data.length > 0) {
                                returnBean.setData(ClsUtils.bytes2HexString(data, 0, data.length));
                            }
                            if (null != callBack) {
                                callBack.receiveResult(returnBean);
                            }
                        }
                    });

                }
            }

            @Override
            public void onWriteFailure(BleException exception) {
                //写入失败
                ReturnBean returnBean = new ReturnBean();
                returnBean.setType(TYPE_SEND);
                returnBean.setCode(RESULT_FAIL);
                returnBean.setData(exception.toString());
                if (null != callBack) {
                    callBack.sendResult(returnBean);
                }
            }
        });

    }


    /**
     * 发送接收数据
     *
     * @param bleDevice 蓝牙对象
     * @param data      数据
     * @param callBack  回调
     */
    public void sendData(final BleDevice bleDevice, String data, final IReceiveCallBack callBack) {
        if (null == bleDevice) {
            Log.e(TAG, "bleDevice == null");
            return;
        }
        if (TextUtils.isEmpty(data)) {
            Log.e(TAG, "sendData:string-->要发送的数据为空");
            return;
        }
        //检查16进制数据是否合法
        if (data.length() % 2 != 0) {
            Log.e(TAG, "sendData:string-->数据不合法");
            return;
        }
        Log.e(TAG, "sendData:string -->准备写入：" + data);
        /**
         * 发送数据
         */
        writeData(bleDevice, hexString2Bytes(data), new BleWriteCallback() {
            @Override
            public void onWriteSuccess(int current, int total, byte[] justWrite) {
                //`current`表示当前发送第几包数据，`total`表示本次总共多少包数据,`justWrite`表示刚刚发送成功的数据包
                Log.e(TAG, "current:" + current + "   total" + total);
                if (current == total) {
                    //发送完成
                    // TODO: 2020/4/21 关注一下
                    SystemClock.sleep(200);
                    notifyData(bleDevice, new BleNotifyCallback() {
                        @Override
                        public void onNotifySuccess() {

                        }

                        @Override
                        public void onNotifyFailure(BleException exception) {
                            //接收失败
                            ReturnBean returnBean = new ReturnBean();
                            returnBean.setType(TYPE_RECEIVE);
                            returnBean.setCode(RESULT_FAIL);
                            returnBean.setData(exception.toString());
                            if (null != callBack) {
                                callBack.receiveResult(returnBean);
                            }
                        }

                        @Override
                        public void onCharacteristicChanged(byte[] data) {
                            ReturnBean returnBean = new ReturnBean();
                            returnBean.setType(TYPE_RECEIVE);
                            returnBean.setCode(RESULT_SUCC);

                            returnBean.setData(ClsUtils.bytes2HexString(data, 0, data.length));
                            if (null != callBack) {
                                callBack.receiveResult(returnBean);
                            }
                        }
                    });

                }
            }

            @Override
            public void onWriteFailure(BleException exception) {
                //发送失败，也返回失败
                ReturnBean returnBean = new ReturnBean();
                returnBean.setType(TYPE_SEND);
                returnBean.setCode(RESULT_FAIL);
                returnBean.setData(exception.toString());
                if (null != callBack) {
                    callBack.receiveResult(returnBean);
                }
            }
        });

    }


    /**
     * 接收通知 有两种方式 indicate和notify
     * indicate是一定会收到通知，notify有可能会丢失数据。indicate底层封装了应答机制，如果没有收到中央设备的回应，
     * 会再次发送直至成功；而notify不会有central收到数据的回应，可能无法保证数据到达的准确性，但是速度快
     * 接收数据频繁的情况下，优先考虑notify形式。
     * 当只需要发送很少且很重要的一条数据给APP的时候，优先考虑indicate形式
     */
    public void notifyData(BleDevice bleDevice) {
        BleManager.getInstance().notify(
                bleDevice,
                UUID_LE_SERVICE,
                UUID_LE_CHARACTERISTIC,
                new BleNotifyCallback() {
                    @Override
                    public void onNotifySuccess() {
                        // 打开通知操作成功
                    }

                    @Override
                    public void onNotifyFailure(BleException exception) {
                        // 打开通知操作失败
                    }

                    @Override
                    public void onCharacteristicChanged(byte[] data) {
                        // 打开通知后，设备发过来的数据将在这里出现
                    }
                });

    }

    private void notifyData(BleDevice bleDevice, BleNotifyCallback bleNotifyCallback) {
        BleManager.getInstance().notify(
                bleDevice,
                UUID_LE_SERVICE,
                UUID_LE_CHARACTERISTIC,
                bleNotifyCallback);
    }

    public void indicateData(BleDevice bleDevice) {
        BleManager.getInstance().indicate(
                bleDevice,
                UUID_LE_SERVICE,
                UUID_LE_CHARACTERISTIC,
                new BleIndicateCallback() {

                    @Override
                    public void onIndicateSuccess() {
                        // 打开通知操作成功
                    }

                    @Override
                    public void onIndicateFailure(BleException exception) {
                        // 打开通知操作失败
                    }

                    @Override
                    public void onCharacteristicChanged(byte[] data) {
                        // 打开通知后，设备发过来的数据将在这里出现
                    }
                });
    }


    /**
     * 关闭notify
     */

    public void closeNotify(BleDevice bleDevice) {
        BleManager.getInstance().stopNotify(bleDevice, UUID_LE_SERVICE, UUID_LE_CHARACTERISTIC);
    }


    /**
     * 关闭indicate
     */

    public void closeIndicate(BleDevice bleDevice) {
        BleManager.getInstance().stopIndicate(bleDevice, UUID_LE_SERVICE, UUID_LE_CHARACTERISTIC);
    }

    /**
     * 读取
     */
    public void readData(BleDevice bleDevice) {
        BleManager.getInstance().read(
                bleDevice,
                UUID_LE_SERVICE,
                UUID_LE_CHARACTERISTIC,
                new BleReadCallback() {
                    @Override
                    public void onReadSuccess(byte[] data) {
                        // 读特征值数据成功
                    }

                    @Override
                    public void onReadFailure(BleException exception) {
                        // 读特征值数据失败
                    }
                });

    }


    /**
     * 写入
     *
     * @param bleDevice                 蓝牙设备
     * @param data                      写入数据
     * @param spilt                     是否使用分包发送 默认分包
     * @param sendNextWhenLastSuccess   是否待收到`onWriteSuccess`之后再进行下一包的发送,默认为true
     * @param intervalBetweenTwoPackage 延时多长时间发送下一包，单位ms，默认0
     */
    public void writeData(BleDevice bleDevice, byte[] data, boolean spilt,
                          boolean sendNextWhenLastSuccess, long intervalBetweenTwoPackage, BleWriteCallback bleWriteCallback) {
        BleManager.getInstance().write(
                bleDevice,
                UUID_LE_SERVICE,
                UUID_LE_CHARACTERISTIC,
                data,
                spilt,
                sendNextWhenLastSuccess,
                intervalBetweenTwoPackage,
                new BleWriteCallback() {
                    @Override
                    public void onWriteSuccess(int current, int total, byte[] justWrite) {
                        //`current`表示当前发送第几包数据，`total`表示本次总共多少包数据,`justWrite`表示刚刚发送成功的数据包

                    }

                    @Override
                    public void onWriteFailure(BleException exception) {

                    }
                }


        );

    }

    /**
     * 写入
     *
     * @param bleDevice 蓝牙设备
     * @param data      写入数据
     */
    private void writeData(BleDevice bleDevice, byte[] data, BleWriteCallback bleWriteCallback) {
        BleManager.getInstance().write(
                bleDevice,
                UUID_LE_SERVICE,
                UUID_LE_CHARACTERISTIC,
                data, bleWriteCallback
        );

    }


    /**
     * 设置最大传输单元MTU
     * 设置MTU，需要在设备连接之后进行操作。
     * 默认每一个BLE设备都必须支持的MTU为23。
     * MTU为23，表示最多可以发送20个字节的数据。
     * 在Android 低版本(API-17 到 API-20)上，没有这个限制。所以只有在API21以上的设备，才会有拓展MTU这个需求。
     * 该方法的参数mtu，最小设置为23，最大设置为512。
     * 并不是每台设备都支持拓展MTU，需要通讯双方都支持才行，也就是说，需要设备硬件也支持拓展MTU该方法才会起效果。
     * 调用该方法后，可以通过onMtuChanged(int mtu)查看最终设置完后，设备的最大传输单元被拓展到多少。
     * 如果设备不支持，可能无论设置多少，最终的mtu还是23。
     */
    public void setMtu(BleDevice bleDevice, int mtu, BleMtuChangedCallback callback) {
        //noinspection AlibabaLowerCamelCaseVariableNaming
        BleManager.getInstance().setMtu(bleDevice, mtu, new BleMtuChangedCallback() {
            @Override
            public void onSetMTUFailure(BleException exception) {
                // 设置MTU失败
            }

            @Override
            public void onMtuChanged(int mtu) {
                // 设置MTU成功，并获得当前设备传输支持的MTU值
            }
        });
    }

    /**
     * 断开设备
     */
    public void dissConnect(BleDevice bleDevice) {
        BleManager.getInstance().disconnect(bleDevice);
    }


}
